{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "from collections import OrderedDict\n",
    "import heapq\n",
    "from typing import (\n",
    "    Hashable,\n",
    "    Callable,\n",
    "    Dict,\n",
    "    Iterable,\n",
    "    Iterator,\n",
    "    List,\n",
    "    Mapping,\n",
    "    MutableMapping,\n",
    "    Optional,\n",
    "    Set,\n",
    "    Tuple,\n",
    "    Union\n",
    ")\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HNSW的直观理解\n",
    "\n",
    "1. NSW路由: 查找最近邻所经过的节点, 一般路由的过程从Zoom-out(经过低度数的节点) -> Zoom-in(经过高度数的节点)的过程. 但是Zoom-out节点很容易陷入局部最小值, 因为度数比较小, 很容易停止继续寻找, 为了解决这个问题需要增加节点的平均度数(但是会增加图的复杂性).\n",
    "    ![image.png](https://cdn.sanity.io/images/vr8gru94/production/d65da887accc1d8d577f236459b16946c9f71a96-1920x960.png)\n",
    "\n",
    "2. HNSW改进: 顶层拥有最长的link, 在底层拥有最短的link(从每个局部最小值中往下寻找). 最小化跨层的重叠会实现增加的性能, 但是会增加搜索的遍历次数(减小ml可以最小化重叠, 将更多向量推到0层). 如下是HNSW的搜索过程:\n",
    "    ![image.png](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*ziU6_KIDqfmaDXKA1cMa8w.png)\n",
    "    如下是ML对插入层的影响:\n",
    "    ![image.png](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*Nl_BPedx-nIkBVMOuxqGPQ.png)\n",
    "    如下图是插入一个新节点的过程:\n",
    "    ![image.png](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*jEGA6ZXYR0qwgrtIEJ9vWg.png)\n",
    "    如下图是启发式搜索的直觉(该选择哪个点进行连接):\n",
    "    ![image.png](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*sRZY7WzZXjT7jhyPLmHOIQ.png)\n",
    "    如下是两种连接方式带来的结果:\n",
    "    ![image.png](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*_2N0HYxF27wMHGrdQRWqTQ.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _Layer(object):\n",
    "    \"\"\"这个就是HNSW中的每一个层, 每一层中包含了一个graph\n",
    "    graph的组织形式是key: {neighbor: float}\n",
    "    \"\"\"\n",
    "    def __init__(self, key: Hashable) -> None:\n",
    "        # self._graph[key] 包含 {j: dist}字典, 它们是key的neighbor\n",
    "        self._graph: Dict[Hashable, Dict[Hashable, float]] = {key: {}}\n",
    "    \n",
    "    def __contains__(self, key: Hashable) -> bool:\n",
    "        # 这个函数本质上就是in\n",
    "        return key in self._graph\n",
    "    \n",
    "    def __getitem__(self, key: Hashable) -> Dict[Hashable, float]:\n",
    "        # 本质上就是[]\n",
    "        return self._graph[key]\n",
    "    \n",
    "    def __setitem__(self, key: Hashable, value: Dict[Hashable, float]) -> None:\n",
    "        self._graph[key] = value\n",
    "\n",
    "    def __delitem__(self, key: Hashable) -> None:\n",
    "        # 如何删除邻居节点 -> key?\n",
    "        del self._graph[key]\n",
    "\n",
    "    def __eq__(self, __value: object) -> bool:\n",
    "        if not isinstance(__value, _Layer):\n",
    "            return False\n",
    "        return self._graph == __value._graph\n",
    "    \n",
    "    def __len__(self) -> int:\n",
    "        return len(self._graph)\n",
    "    \n",
    "    def __iter__(self) -> Iterable[Hashable]:\n",
    "        return iter(self._graph)\n",
    "    \n",
    "    def copy(self) -> _Layer:\n",
    "        \"\"\"Deep copy\"\"\"\n",
    "        new_layer = _Layer(None)\n",
    "        # dict(v)这里相当于创建了一个新的dict(deep copy)\n",
    "        new_layer._graph = {k: dict(v) for k, v in self._graph.items()}\n",
    "        return new_layer\n",
    "    \n",
    "    def get_reverse_edges(self, key: Hashable) -> Set[Hashable]:\n",
    "        reverse_edges = set()\n",
    "        for neighbor, neighbors in self._graph.items():\n",
    "            if key in neighbors:\n",
    "                reverse_edges.add(neighbor)\n",
    "        return reverse_edges\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _LayerWithReversedEdges(_Layer):\n",
    "    \"\"\"维护逆向边的Layer\n",
    "    原本的Layer只是一个key -> neighbors的映射\n",
    "    维护逆向边之后添加了neigbor中反向到key的边\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, key: Hashable) -> None:\n",
    "        # key -> (neigbors, dist)\n",
    "        self._graph: Dict[Hashable, Dict[Hashable, float]] = {key: {}}\n",
    "        # key -> neigbors\n",
    "        self._reverse_edges: Dict[Hashable, Set] = {}\n",
    "    \n",
    "    def __setitem__(self, key: Hashable, value: Dict[Hashable, float]) -> None:\n",
    "        old_neighbors = self._graph.get(key, {})\n",
    "        self._graph[key] = value\n",
    "        for neighbor in old_neighbors:\n",
    "            self._reverse_edges[neighbor].discard(key)\n",
    "        for neighbor in value:\n",
    "            self._reverse_edges.setdefault(neighbor, set()).add(key)\n",
    "        if key not in self._reverse_edges:\n",
    "            self._reverse_edges[key] = set()\n",
    "    \n",
    "    def __delitem__(self, key: Hashable) -> None:\n",
    "        old_neighbors = self._graph.get(key, {})\n",
    "        del self._graph[key]\n",
    "        for neighbor in old_neighbors:\n",
    "            self._reverse_edges[neighbor].discard(key)\n",
    "    \n",
    "    def __eq__(self, __value: object) -> bool:\n",
    "        if not isinstance(__value, _LayerWithReversedEdges):\n",
    "            return False\n",
    "        return (\n",
    "            self._graph == __value._graph\n",
    "            and self._reverse_edges == __value._reverse_edges\n",
    "        )\n",
    "    \n",
    "    def __len__(self) -> int:\n",
    "        return len(self._graph)\n",
    "    \n",
    "    def __iter__(self) -> Iterable[Hashable]:\n",
    "        return iter(self._graph)\n",
    "    \n",
    "    def copy(self) -> _LayerWithReversedEdges:\n",
    "        new_layer = _LayerWithReversedEdges(None)\n",
    "        new_layer._graph = {k: dict(v) for k, v in self._graph.items()}\n",
    "        new_layer._reverse_edges = {k: set(v) for k, v in self._reverse_edges.items()}\n",
    "        return new_layer\n",
    "    \n",
    "    def get_reverse_edges(self, key: Hashable) -> Set[Hashable]:\n",
    "        return self._reverse_edges[key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _Node(object):\n",
    "    \"\"\"A node in graph, 每一个key对应的真实point信息\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, key: Hashable, point: np.ndarray, is_deleted=False) -> None:\n",
    "        self.key = key\n",
    "        self.point = point\n",
    "        self.is_deleted = is_deleted\n",
    "    \n",
    "    def __eq__(self, __value: object) -> bool:\n",
    "        if not isinstance(__value, _Node):\n",
    "            return False\n",
    "        return (\n",
    "            self.key == __value.key\n",
    "            and np.array_equal(self.point, __value.point)\n",
    "            and self.is_deleted == __value.is_deleted\n",
    "        )\n",
    "    \n",
    "    def __hash__(self) -> int:\n",
    "        return hash(self.key)\n",
    "    \n",
    "    def __repr__(self) -> str:\n",
    "        return (\n",
    "            f\"_Node(key={self.key}, point={self.point}, is_deleted={self.is_deleted})\"\n",
    "        )\n",
    "    \n",
    "    def copy(self) -> _Node:\n",
    "        return _Node(self.key, self.point, self.is_deleted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HNSW(MutableMapping):\n",
    "    \"\"\"\n",
    "    HNSW\n",
    "\n",
    "    Args:\n",
    "        distance_function: (v1, v2) -> float,\n",
    "        m(int): 每个节点keep的neighbors数目\n",
    "        ef_construction(int): 构建过程中考虑的neighbors数目\n",
    "        m0: 0层每个节点保存的邻居数目(m * 2)\n",
    "        seed: 随机数种子\n",
    "        reverse_edges: 是否保存反向边\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        distance_func: Callable[[np.ndarray, np.ndarray], float],\n",
    "        m: int = 16,\n",
    "        ef_construction: int = 200,\n",
    "        m0: Optional[int] = None,\n",
    "        seed: Optional[int] = None,\n",
    "        reversed_edges: bool = False\n",
    "    ) -> None:\n",
    "        # nodes: key -> _Node的映射\n",
    "        self._nodes: OrderedDict[Hashable, _Node] = OrderedDict()\n",
    "        self._distance_func = distance_func\n",
    "        # 非base_layer允许保存的最大邻居数目\n",
    "        self._m = m\n",
    "        # 构建图的过程中考虑的邻居数目\n",
    "        self._ef_construction = ef_construction\n",
    "        # base_layer允许保存的最大邻居数目\n",
    "        self._m0 = 2 * m if m0 is None else m0\n",
    "        # 每一层的放缩因子\n",
    "        self._level_mult = 1 / np.log(m)\n",
    "        # 每一层对应的图\n",
    "        self._graphs: List[_Layer] = []\n",
    "        # 入口点\n",
    "        self._entry_point = None\n",
    "        self._random = np.random.RandomState(seed)\n",
    "        # 每一层的类\n",
    "        self._layer_class = _LayerWithReversedEdges if reversed_edges else _Layer\n",
    "    \n",
    "    def __len__(self) -> int:\n",
    "        \"\"\"return none-deleted node number\"\"\"\n",
    "        return sum(not node.is_deleted for node in self._nodes.values())\n",
    "    \n",
    "    def __contains__(self, key: Hashable) -> bool:\n",
    "        return key in self._nodes and not self._nodes[key].is_deleted\n",
    "    \n",
    "    def __getitem__(self, key: Hashable) -> np.ndarray:\n",
    "        if key not in self:\n",
    "            raise KeyError(key)\n",
    "        return self._nodes[key].point\n",
    "    \n",
    "    def __setitem__(self, key: Hashable, value: np.ndarray) -> None:\n",
    "        self.insert(key, value)\n",
    "\n",
    "    def __delitem__(self, key: Hashable) -> None:\n",
    "        self.remove(key)\n",
    "\n",
    "    def __iter__(self) -> Iterator[Hashable]:\n",
    "        return (key for key in self._nodes if not self._nodes[key].is_deleted)\n",
    "    \n",
    "    def reversed(self) -> Iterator[Hashable]:\n",
    "        return (key for key in reversed(self._nodes) if not self._nodes[key].is_deleted)\n",
    "    \n",
    "    def __eq__(self, __value: object) -> bool:\n",
    "        if not isinstance(__value, HNSW):\n",
    "            return False\n",
    "        if (\n",
    "            self._distance_func != __value._distance_func\n",
    "            or self._m != __value._m\n",
    "            or self._ef_construction != __value._ef_construction\n",
    "            or self._m0 != __value._m0\n",
    "            or self._level_mult != __value._level_mult\n",
    "            or self._entry_point != __value._entry_point\n",
    "        ):\n",
    "            return False\n",
    "        \n",
    "        random_state_1 = self._random.get_state()\n",
    "        random_state_2 = __value._random.get_state()\n",
    "        for i in range(len(random_state_1)):\n",
    "            if isinstance(random_state_1[i], np.ndarray):\n",
    "                if not np.array_equal(random_state_1[i], random_state_2[i]):\n",
    "                    return False\n",
    "            else:\n",
    "                if random_state_1[i] != random_state_2[i]:\n",
    "                    return False\n",
    "        \n",
    "        return (\n",
    "            all(key in self._nodes for key in __value._nodes)\n",
    "            and all(key in __value._nodes for key in self._nodes)\n",
    "            and all(self._nodes[key] == __value._nodes[key] for key in self._nodes)\n",
    "            and self._graphs == __value._graphs\n",
    "        )\n",
    "    \n",
    "    def get(\n",
    "        self, key: Hashable, default: Optional[np.ndarray] = None\n",
    "    ) -> Union[np.ndarray, None]:\n",
    "        if key not in self:\n",
    "            return default\n",
    "        return self._nodes[key].point\n",
    "    \n",
    "    def items(self) -> Iterator[Tuple[Hashable, np.ndarray]]:\n",
    "        return (\n",
    "            (key, node.point)\n",
    "            for key, node in self._nodes.items()\n",
    "            if not node.is_deleted\n",
    "        )\n",
    "    \n",
    "    def keys(self) -> Iterator[Hashable]:\n",
    "        return (key for key in self._nodes if not self._nodes[key].is_deleted)\n",
    "    \n",
    "    def values(self) -> Iterator[np.ndarray]:\n",
    "        return (node.point for node in self._nodes.values() if not node.is_deleted)\n",
    "    \n",
    "    def pop(\n",
    "        self, key: Hashable, default: Optional[np.ndarray] = None, hard: bool = False\n",
    "    ) -> np.ndarray:\n",
    "        if key not in self:\n",
    "            if default is None:\n",
    "                raise KeyError(key)\n",
    "            return default\n",
    "        point = self._nodes[key].point\n",
    "        self.remove(key, hard=hard)\n",
    "        return point\n",
    "    \n",
    "    def popitem(\n",
    "        self, last: bool = True, hard: bool = False\n",
    "    ) -> Tuple[Hashable, np.ndarray]:\n",
    "        if not self._nodes:\n",
    "            raise KeyError(\"popitem(): index is empty\")\n",
    "        if last:\n",
    "            key = next(\n",
    "                (\n",
    "                    key\n",
    "                    for key in reversed(self._nodes)\n",
    "                    if not self._nodes[key].is_deleted\n",
    "                ),\n",
    "                None,\n",
    "            )\n",
    "        else:\n",
    "            key = next(\n",
    "                (key for key in self._nodes if not self._nodes[key].is_deleted), None\n",
    "            )\n",
    "        if key is None:\n",
    "            raise KeyError(\"popitem(): index is empty\")\n",
    "        point = self._nodes[key].point\n",
    "        self.remove(key, hard=hard)\n",
    "        return key, point\n",
    "    \n",
    "    def clear(self) -> None:\n",
    "        self._nodes = {}\n",
    "        self._graphs = []\n",
    "        self._entry_point = None\n",
    "    \n",
    "    def copy(self) -> HNSW:\n",
    "        new_index = HNSW(\n",
    "            self._distance_func,\n",
    "            m=self._m,\n",
    "            ef_construction=self._ef_construction,\n",
    "            m0=self._m0\n",
    "        )\n",
    "        new_index._nodes = OrderedDict(\n",
    "            (key, node.copy()) for key, node in self._nodes.items()\n",
    "        )\n",
    "        new_index._graphs = [layer.copy() for layer in self._graphs]\n",
    "        new_index._entry_point = self._entry_point\n",
    "        new_index._random.set_state(self._random.get_state())\n",
    "        return new_index\n",
    "    \n",
    "    def update(self, other: Union[Mapping, HNSW]) -> None:\n",
    "        for key, point in other.items():\n",
    "            self.insert(key, point)\n",
    "    \n",
    "    #! 可能存在问题\n",
    "    def setdefault(self, key: Hashable, default: np.ndarray) -> np.ndarray:\n",
    "        if default is None:\n",
    "            raise ValueError(\"Default value cann't be None\")\n",
    "        if key not in self._nodes or self._nodes[key].is_deleted:\n",
    "            self.insert(key, default)\n",
    "        return self._nodes[key].point\n",
    "    \n",
    "    def insert(\n",
    "        self,\n",
    "        key: Hashable,\n",
    "        new_point: np.ndarray,\n",
    "        ef: Optional[int] = None,\n",
    "        level: Optional[int] = None,\n",
    "    ) -> None:\n",
    "        \"\"\"将一个新的点add到index中, 整体的思路如下:\n",
    "            1. 如果这个key在_nodes中, 存在是否软删除的考虑\n",
    "            2. 进入HNSW的插入流程:\n",
    "                2.1 首先判断当前节点要插入的层 l\n",
    "                2.2 从L -> l + 1找到最近邻的点作为入口点ep\n",
    "                2.3 从l -> 0 从ep中搜索ef个邻居, 根据目标选择m或者m0个连接双向边, 对双向节点都需要选择 \n",
    "                2.4 如果l > L, 设置new_point作为入口点\n",
    "        \n",
    "        \"\"\"\n",
    "        if ef is None:\n",
    "            ef = self._ef_construction\n",
    "        if key in self._nodes:\n",
    "            if self._nodes[key].is_deleted:\n",
    "                self._nodes[key].is_deleted = False\n",
    "            self._update(key, new_point, ef)\n",
    "            return\n",
    "        \n",
    "        if level is None:\n",
    "            level = int(-np.log(self._random.random_sample()) * self._level_mult)\n",
    "        self._nodes[key] = _Node(key, new_point)\n",
    "\n",
    "        if (\n",
    "            self._entry_point is not None\n",
    "        ): # HNSW is not emtpy\n",
    "            dist = self._distance_func(new_point, self._nodes[self._entry_point].point)\n",
    "            point = self._entry_point\n",
    "            # 这一步是只找点, 不进行插入操作\n",
    "            for layer in reversed(self._graphs[level + 1: ]):\n",
    "                # 找到所有层中从L->level+1中最近的一个点\n",
    "                point, dist = self._search_ef1(\n",
    "                    new_point, point, dist, layer, allow_soft_deleted=True\n",
    "                )\n",
    "            \n",
    "            # 让这个点作为入口点, 从leve -> 0层查找最近的ef个邻居, 并且进行连边\n",
    "            entry_points = [(-dist, point)]\n",
    "            for layer in reversed(self._graphs[: level + 1]):\n",
    "                # 当前层保存的最大邻居数目\n",
    "                level_m = self._m if layer is not self._graphs[0] else self._m0\n",
    "                # [(-dist, p)] is a heap in layer层\n",
    "                # 从entry_points入手, 找到最近邻的ef个邻居节点\n",
    "                entry_points = self._search_base_layer(\n",
    "                    new_point, entry_points, layer, ef, allow_soft_deleted=True\n",
    "                )\n",
    "\n",
    "                # 找到最近邻的ef个节点之后\n",
    "                # 首先选择其中的m或m0个节点进行连边\n",
    "                layer[key] = {\n",
    "                    p: d\n",
    "                    for d, p in self._heuristic_prune(\n",
    "                        [(-mdist, p) for mdist, p in entry_points], level_m\n",
    "                    )\n",
    "                }\n",
    "\n",
    "                # 因为key连边之后, neighbor可能违反m规定, 因此需要重新连边\n",
    "                # 这里的含义就是说即使增加了双向边, 但是这个边最终也会被剪裁掉\n",
    "                for neighbor_key, dist in layer[key].items():\n",
    "                    layer[neighbor_key] = {\n",
    "                        p: d\n",
    "                        for d, p in self._heuristic_prune(\n",
    "                            [(d, p) for p, d in layer[neighbor_key].items()]\n",
    "                            + [(dist, key)],\n",
    "                            level_m\n",
    "                        )\n",
    "                    }\n",
    "\n",
    "        # 从L->level添加这个key, 当HNSW为空的情况下或者层数升高的时候\n",
    "        for _ in range(len(self._graphs), level + 1):\n",
    "            self._graphs.append(self._layer_class(key))\n",
    "            self._entry_point = key\n",
    "\n",
    "    def remove(\n",
    "        self, \n",
    "        key: Hashable, \n",
    "        hard: bool = False,\n",
    "        ef: Optional[int] = None\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        remove的方式分为两种, Soft和Hard:\n",
    "            * Soft: 标记为deleted, 但是数据和出边都被保留(入边被delete), 未来的查询不会返回这个点, 也不会导航到这个点, 但是这个点可以用于图的遍历\n",
    "            * Hard: 完全从索引中删除, 出边也被removed, 这样需要重新进行连边\n",
    "        \"\"\"\n",
    "        if not self._nodes or key not in self._nodes:\n",
    "            raise KeyError(key)\n",
    "        \n",
    "        if self._entry_point == key:\n",
    "            # 如果入口点和key相同, 那么就需要重新分配入口点\n",
    "            new_entry_point = None\n",
    "            for layer in reversed(self._graphs):\n",
    "                new_entry_point = next(\n",
    "                    (p for p in layer if p != key and not self._nodes[p].is_deleted),\n",
    "                    None,\n",
    "                )\n",
    "                \n",
    "                if new_entry_point is not None:\n",
    "                    break\n",
    "                else:\n",
    "                    # 这一层的最后一个节点都没有, 那么直接pop这一个层\n",
    "                    self._graphs.pop()\n",
    "            \n",
    "            if new_entry_point is None:\n",
    "                self.clear()\n",
    "                return\n",
    "            self._entry_point = new_entry_point\n",
    "        \n",
    "        if ef is None:\n",
    "            ef = self._ef_construction\n",
    "\n",
    "        # Soft remove\n",
    "        self._nodes[key].is_deleted = True\n",
    "        if not hard:\n",
    "            return\n",
    "        \n",
    "        # Hard remove\n",
    "        # 找到所有需要修改的点, 也就是key的邻居\n",
    "        keys_to_update = set()\n",
    "        for layer in self._graphs:\n",
    "            if key not in layer:\n",
    "                break\n",
    "            keys_to_update.update(layer.get_reverse_edges(key))\n",
    "        \n",
    "        # 修复每一个key的连接\n",
    "        for key_to_update in keys_to_update:\n",
    "            self._repair_connections(\n",
    "                key_to_update,\n",
    "                self._nodes[key_to_update].point,\n",
    "                ef,\n",
    "                key_to_delete=key\n",
    "            )\n",
    "        \n",
    "        # Hard remove这个key\n",
    "        for layer in self._graphs:\n",
    "            if key not in layer:\n",
    "                break\n",
    "            del layer[key]\n",
    "        del self._nodes[key]\n",
    "            \n",
    "        \n",
    "\n",
    "\n",
    "    def _update(self, key: Hashable, new_point: np.ndarray, ef: int) -> None:\n",
    "        \"\"\"当key还存在在_nodes当中的时候, 如果更新了new_point, 更新索引\n",
    "            所以这里的核心思路在于:\n",
    "                1. 首先更新key的邻居的连接\n",
    "                    1.1 找到key的所有一阶和二阶邻居\n",
    "                    1.2 对于key的每一个一阶邻居, 按照优先队列的方式找到最近邻, 裁边后进行连接\n",
    "                2. 修复key的连接\n",
    "        \"\"\"\n",
    "        if key not in self._nodes:\n",
    "            raise KeyError(key)\n",
    "        self._nodes[key].point = new_point\n",
    "        # 如果它就是第一个点\n",
    "        if self._entry_point == key and len(self._nodes) == 1:\n",
    "            return\n",
    "        \n",
    "        # 找到key所在的layer, 更新更新连边\n",
    "        for layer in self._graphs:\n",
    "            if key not in layer:\n",
    "                break\n",
    "\n",
    "            layer_m = self._m if layer is not self._graphs[0] else self._m0\n",
    "            neighbor_keys = set([key])\n",
    "\n",
    "            # 收集所有的一跳邻居和二跳邻居\n",
    "            for p in layer[key].keys():\n",
    "                neighbor_keys.add(p)\n",
    "                for p2 in layer[p].keys():\n",
    "                    neighbor_keys.add(p2)\n",
    "            \n",
    "            # 对于所有的一阶邻居\n",
    "            for p in layer[key].keys():\n",
    "                candidates = []\n",
    "                # 获取可以keep的最大邻居数目\n",
    "                elem_to_keep = min(ef, len(neighbor_keys) - 1)\n",
    "\n",
    "                for candidate_key in neighbor_keys:\n",
    "                    if candidate_key == p:\n",
    "                        continue\n",
    "                    # 计算当前节点和所有二阶内邻居节点的距离\n",
    "                    dist = self._distance_func(\n",
    "                        self._nodes[candidate_key].point, self._nodes[p].point\n",
    "                    )\n",
    "                    # 找到候选者, 放入候选队列中\n",
    "                    if len(candidates) < elem_to_keep:\n",
    "                        heapq.heappush(candidates, (-dist, candidate_key))\n",
    "                    elif dist < -candidates[0][0]:\n",
    "                        heapq.heappushpop(candidates, (-dist, candidate_key))\n",
    "                # 进行剪枝连边\n",
    "                layer[p] = {\n",
    "                    p2: d2\n",
    "                    for d2, p2 in self._heuristic_prune(\n",
    "                        [(-md, p) for md, p in candidates], layer_m\n",
    "                    )\n",
    "                }\n",
    "        # 修复最原本的连接\n",
    "        self._repair_connections(key, new_point, ef)\n",
    "    \n",
    "\n",
    "    def _repair_connections(\n",
    "        self,\n",
    "        key: Hashable,\n",
    "        new_point: np.ndarray,\n",
    "        ef: int,\n",
    "        key_to_delete: Optional[Hashable] = None\n",
    "    ) -> None:\n",
    "        \"\"\"在之前的步骤中, 已经处理完了key邻居的连接情况\n",
    "            那么接下来我们就需要处理key的连接了, 这里本质上和新插入节点的思路一样\n",
    "            本质上, 这个函数就是重新找key的边, 同时在明白key_to_delete的思路下\n",
    "        \"\"\"\n",
    "        entry_point = self._entry_point\n",
    "        entry_point_dist = self._distance_func(\n",
    "            new_point, self._nodes[entry_point].point\n",
    "        )\n",
    "        entry_points = [(-entry_point_dist, entry_point)]\n",
    "        for layer in reversed(self._graphs):\n",
    "            # 如果不在这一层, 寻找最近邻\n",
    "            if key not in layer:\n",
    "                entry_point, entry_point_dist = self._search_ef1(\n",
    "                    new_point,\n",
    "                    entry_point,\n",
    "                    entry_point_dist,\n",
    "                    layer,\n",
    "                    allow_soft_deleted=True,\n",
    "                    key_to_hard_delete=key_to_delete\n",
    "                )\n",
    "                # 更新入口点\n",
    "                entry_points = [(-entry_point_dist, entry_point)]\n",
    "            else:\n",
    "                # 如果在这一层, 选择ef个最近邻, 裁边, 连接\n",
    "                level_m = self._m if layer is not self._graphs[0] else self._m0\n",
    "                entry_points = self._search_base_layer(\n",
    "                    new_point,\n",
    "                    entry_points,\n",
    "                    layer,\n",
    "                    ef + 1, # 增加1是因为它自己\n",
    "                    allow_soft_deleted=True,\n",
    "                    key_to_hard_delete=key_to_delete\n",
    "                )\n",
    "                # 过滤掉自己\n",
    "                filtered_candidate = [(-md, p) for md, p in entry_points if p != key]\n",
    "                # 连边\n",
    "                layer[key] = {\n",
    "                    p: d for d, p in self._heuristic_prune(filtered_candidate, level_m)\n",
    "                }\n",
    "    \n",
    "    def query(\n",
    "        self,\n",
    "        query_point: np.ndarray,\n",
    "        k: Optional[int] = None,\n",
    "        ef: Optional[int] = None\n",
    "    ) -> List[Tuple[Hashable, float]]:\n",
    "        \"\"\"查询K最近邻, 从非0层找到最近邻\n",
    "        在第0层进行查询\n",
    "        \"\"\"\n",
    "        if ef is None:\n",
    "            ef = self._ef_construction\n",
    "        if self._entry_point is None:\n",
    "            raise ValueError(\"Entry point not found\")\n",
    "        entry_point_dist = self._distance_func(\n",
    "            query_point, self._nodes[self._entry_point].point\n",
    "        )\n",
    "        entry_point = self._entry_point\n",
    "\n",
    "        # 查找非0层的最近邻\n",
    "        for layer in reversed(self._graphs[1:]):\n",
    "            entry_point, entry_point_dist = self._search_ef1(\n",
    "                query_point, entry_point, entry_point_dist, layer\n",
    "            )\n",
    "        \n",
    "        # 在第0层的最近邻附近进行最终的查询\n",
    "        candidates = self._search_base_layer(\n",
    "            query_point, [(-entry_point_dist, entry_point)], self._graphs[0], ef\n",
    "        )\n",
    "\n",
    "        # k最近邻\n",
    "        if k is not None:\n",
    "            candidates = heapq.nlargest(k, candidates)\n",
    "        # 排序后的最近邻\n",
    "        else:\n",
    "            candidates.sort(reverse=True)\n",
    "        \n",
    "        return [(key, -mdist) for mdist, key in candidates]\n",
    "\n",
    "\n",
    "    def _search_ef1(\n",
    "        self,\n",
    "        query_point: np.ndarray,\n",
    "        entry_point: Hashable,\n",
    "        entry_point_dist: float,\n",
    "        layer: _Layer,\n",
    "        allow_soft_deleted: bool = False,\n",
    "        key_to_hard_delete: Optional[Hashable] = None,\n",
    "    ) -> Tuple[Hashable, float]:\n",
    "        \"\"\"贪心搜索最近的邻居(layer层), 给定entry, 查找query的最近邻\n",
    "            整体算法思路如下:\n",
    "                1. 本质上就是一个优先队列找邻居的过程\n",
    "                2. 找到最优的邻居就停止\n",
    "        \"\"\"\n",
    "        candidates = [(entry_point_dist, entry_point)]\n",
    "        visited = set([entry_point])\n",
    "        best = entry_point\n",
    "        best_dist = entry_point_dist\n",
    "        while candidates:\n",
    "            dist, current = heapq.heappop(candidates)\n",
    "            if dist > best_dist:\n",
    "                break\n",
    "            neighbors = [p for p in layer[current] if p not in visited]\n",
    "            visited.update(neighbors)\n",
    "            dists = [\n",
    "                self._distance_func(query_point, self._nodes[p].point)\n",
    "                for p in neighbors\n",
    "            ]\n",
    "            for p, d in zip(neighbors, dists):\n",
    "                if d < best_dist:\n",
    "                    # 如果这个节点将要被删除, 那么可以继续探索, 但是不允许成为最优节点\n",
    "                    if (not allow_soft_deleted and self._nodes[p].is_deleted) or (\n",
    "                        p == key_to_hard_delete\n",
    "                    ):\n",
    "                        pass\n",
    "                    else:\n",
    "                        best, best_dist = p, d\n",
    "                    heapq.heappush(candidates, (d, p))\n",
    "        return best, best_dist\n",
    "    \n",
    "    def _search_base_layer(\n",
    "        self,\n",
    "        query_point: np.ndarray,\n",
    "        entry_points: List[Tuple[float, Hashable]],\n",
    "        layer: _Layer,\n",
    "        ef: int,\n",
    "        allow_soft_deleted: bool = False,\n",
    "        key_to_hard_delete: Optional[Hashable] = None\n",
    "    ) -> List[Tuple[float, Hashable]]:\n",
    "        \"\"\"Finding neigbors in layer, ef is consider neighbors\n",
    "            本质上还是采用优先队列的方式贪心寻找最近邻的ef个点, 但是会利用如下的剪枝策略:\n",
    "                1. 如果candidate的最小值大于result中的最大值可以选择终止\n",
    "            return: [(-dist, key)]\n",
    "        \"\"\"\n",
    "        # [(dist, point)]\n",
    "        candidates = [(-mdist, p) for mdist, p in entry_points]\n",
    "        # 变成最小堆\n",
    "        heapq.heapify(candidates)\n",
    "\n",
    "        visited = set(p for _, p in entry_points)\n",
    "        while candidates:\n",
    "            dist, current = heapq.heappop(candidates)\n",
    "\n",
    "            # furtherest的点(也就是最远点)\n",
    "            closet_dist = -entry_points[0][0]\n",
    "            # 如果满足剪枝条件则终止\n",
    "            if dist > closet_dist:\n",
    "                break\n",
    "            \n",
    "            # 找到候选者的邻居\n",
    "            neighbors = [p for p in layer[current] if p not in visited]\n",
    "            visited.update(neighbors)\n",
    "\n",
    "            # 计算候选者邻居的距离\n",
    "            dists = [\n",
    "                self._distance_func(query_point, self._nodes[p].point)\n",
    "                for p in neighbors\n",
    "            ]\n",
    "\n",
    "            # 如果小于最远点就可以加入\n",
    "            for p, dist in zip(neighbors, dists):\n",
    "                if (not allow_soft_deleted and self._nodes[p].is_deleted) or (\n",
    "                    p == key_to_hard_delete\n",
    "                ):  \n",
    "                    # 小于最远点, 保持探索但是不加入\n",
    "                    if dist <= closet_dist:\n",
    "                        # 继续探索, 但是不加入entry_points\n",
    "                        heapq.heappush(candidates, (dist, p))\n",
    "                elif len(entry_points) < ef:\n",
    "                    # result结果不足, 加入候选点继续判断\n",
    "                    heapq.heappush(candidates, (dist, p))\n",
    "                    # 考虑的邻居数目不足\n",
    "                    heapq.heappush(entry_points, (-dist, p))\n",
    "                    # 更新最远巨鹿\n",
    "                    closet_dist = -entry_points[0][0]\n",
    "                elif dist <= closet_dist:\n",
    "                    heapq.heappush(candidates, (dist, p))\n",
    "                    # pop and return small, add new item\n",
    "                    heapq.heapreplace(entry_points, (-dist, p))\n",
    "                    closet_dist = -entry_points[0][0]\n",
    "        return entry_points\n",
    "    \n",
    "    def _heuristic_prune(\n",
    "        self, candidates: List[Tuple[float, Hashable]], max_size: int\n",
    "    ) -> List[Tuple[float, Hashable]]:\n",
    "        \"\"\"Keep only max_size neighbors\n",
    "        核心思路就是说维护一个prune\n",
    "        选出候选的vector\n",
    "        选点的核心思路在于:\n",
    "            1. 尽量进行分散, 不要聚集在一个簇里面, 否则没什么意思(也就是说从其它簇中选择最小值)\n",
    "\n",
    "        Args:\n",
    "            candidates: [(distance, key)]\n",
    "        \"\"\"\n",
    "        \n",
    "        if len(candidates) < max_size:\n",
    "            return candidates\n",
    "        \n",
    "        heapq.heapify(candidates)\n",
    "        pruned = []\n",
    "        # 每次弹出最小的候选者\n",
    "        # 如果这个候选者和所有pruned的vector距离都小于候选者距离, 则不行\n",
    "        # 可以理解成增加随机性, 尽量不再同一个簇中\n",
    "        while candidates:\n",
    "            if len(pruned) >= max_size:\n",
    "                break\n",
    "            candidate_dist, candidate_key = heapq.heappop(candidates)\n",
    "            good = True\n",
    "            for _, selected_key in pruned:\n",
    "                dist_to_selected_neighbor = self._distance_func(\n",
    "                    self._nodes[selected_key].point, self._nodes[candidate_key].point\n",
    "                )\n",
    "                if dist_to_selected_neighbor < candidate_dist:\n",
    "                    good = False\n",
    "                    break\n",
    "            if good:\n",
    "                pruned.append((candidate_dist, candidate_key))\n",
    "        return pruned\n",
    "    \n",
    "    def clean(self, ef: Optional[int] = None) -> None:\n",
    "        \"\"\"将所有Soft remove的点从索引中删除\n",
    "        \"\"\"\n",
    "        keys_to_move = [key for key in self._nodes if self._nodes[key].is_deleted]\n",
    "        for key in keys_to_move:\n",
    "            self.remove(key, ef=ef, hard=True)\n",
    "    \n",
    "    def merge(self, other: HNSW) -> HNSW:\n",
    "        new_index = self.copy()\n",
    "        new_index.update(other)\n",
    "        return new_index\n",
    "    \n",
    "    def save(self, path: str):\n",
    "        import dill as pickle\n",
    "        with open(path, 'wb') as f:\n",
    "            pickle.dump(self, f)\n",
    "    \n",
    "    @staticmethod\n",
    "    def load(path: str) -> HNSW:\n",
    "        import dill as pickle\n",
    "        with open(path, 'rb') as f:\n",
    "            return pickle.load(path)\n",
    "        \n",
    "    \n",
    "    @staticmethod\n",
    "    def linear_query(query: np.ndarray, data: np.ndarray, distance_func: Callable[[np.ndarray, np.ndarray], float], k: int=1) -> List[Tuple[Hashable, float]]:\n",
    "        candiate = []\n",
    "        for i, d in enumerate(data):\n",
    "            if len(candiate) < k:\n",
    "                heapq.heappush(candiate, (-distance_func(d, query), i))\n",
    "            else:\n",
    "                heapq.heappushpop(candiate, (-distance_func(d, query), i))\n",
    "        candiate.sort(reverse=True)\n",
    "        return [(i, -d) for d, i in candiate]\n",
    "    \n",
    "    @staticmethod\n",
    "    def recall(predict: List[Tuple[Hashable, float]], ground: List[Tuple[Hashable, float]]):\n",
    "        assert len(predict) == len(ground), \"two set should have same size\"\n",
    "        predict_key = set([key for key, _ in predict])\n",
    "        ground_key = set([key for key, _ in ground])\n",
    "        hit = predict_key.intersection(ground_key)\n",
    "        return len(hit) / len(predict)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "def recall_with_topk(\n",
    "    index: HNSW, \n",
    "    data: np.ndarray, \n",
    "    distance_func: Callable[[np.ndarray, np.ndarray], float],\n",
    "    max_topk: int) -> List[float]:\n",
    "    recall = []\n",
    "    lt, ht = 0, 0\n",
    "    for i in range(1, max_topk):\n",
    "        q = np.random.randn(128)\n",
    "        t1 = time()\n",
    "        predict = index.query(q, i, max(i, index._ef_construction))\n",
    "        t2 = time()\n",
    "        ground = HNSW.linear_query(q, data, distance_func, i)\n",
    "        t3 = time()\n",
    "        ht += t2 - t1\n",
    "        lt += t3 - t2\n",
    "        recall.append(HNSW.recall(predict, ground))\n",
    "    print(f'HNSW Time: {ht}, Linear Time: {lt}')\n",
    "    return recall "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm.notebook import tqdm\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.random.randn(100000, 128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9e3d35d182f466fb3cc5e28fa2aea48",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = HNSW(distance_func=lambda x, y: np.linalg.norm(x - y))\n",
    "for i, d in enumerate(tqdm(data)):\n",
    "    index.insert(i, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HNSW Time: 6.671274662017822, Linear Time: 83.04357075691223\n",
      "HNSW Time: 6.120171546936035, Linear Time: 81.30230402946472\n",
      "HNSW Time: 6.003578424453735, Linear Time: 81.11981344223022\n",
      "HNSW Time: 5.9618940353393555, Linear Time: 79.90744948387146\n",
      "HNSW Time: 6.608896017074585, Linear Time: 79.68056154251099\n",
      "HNSW Time: 7.8432300090789795, Linear Time: 81.49499893188477\n",
      "HNSW Time: 6.407568693161011, Linear Time: 79.69319248199463\n",
      "HNSW Time: 5.969627380371094, Linear Time: 79.79881763458252\n",
      "HNSW Time: 5.777933597564697, Linear Time: 79.9929792881012\n",
      "HNSW Time: 5.599669694900513, Linear Time: 78.21892213821411\n"
     ]
    }
   ],
   "source": [
    "recall_list = []\n",
    "for i in range(10):\n",
    "    recalls = recall_with_topk(index, data, index._distance_func, max_topk=100)\n",
    "    recall_list.append(recalls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for r in recall_list:\n",
    "    plt.plot(range(1, 100), r)\n",
    "plt.xlabel('topk')\n",
    "plt.ylabel('recall')\n",
    "plt.title('recall with topk')\n",
    "plt.savefig('result/hnsw_recall_topk_norm_0_1_100000_128_l2.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "index.save('index/hnsw_norm_0_1_100000_128_l2.pickle')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "file must have 'read' and 'readline' attributes",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m index \u001b[38;5;241m=\u001b[39m \u001b[43mHNSW\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mindex/hnsw_norm_0_1_100000_128_l2.pickle\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36mHNSW.load\u001b[0;34m(path)\u001b[0m\n\u001b[1;32m    630\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mdill\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpickle\u001b[39;00m\n\u001b[1;32m    631\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(path, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[0;32m--> 632\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mpickle\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/anaconda3/envs/ann/lib/python3.10/site-packages/dill/_dill.py:287\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, ignore, **kwds)\u001b[0m\n\u001b[1;32m    281\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mload\u001b[39m(file, ignore\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m    282\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    283\u001b[0m \u001b[38;5;124;03m    Unpickle an object from a file.\u001b[39;00m\n\u001b[1;32m    284\u001b[0m \n\u001b[1;32m    285\u001b[0m \u001b[38;5;124;03m    See :func:`loads` for keyword arguments.\u001b[39;00m\n\u001b[1;32m    286\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 287\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mUnpickler\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mignore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mignore\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mload()\n",
      "File \u001b[0;32m~/anaconda3/envs/ann/lib/python3.10/site-packages/dill/_dill.py:437\u001b[0m, in \u001b[0;36mUnpickler.__init__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    435\u001b[0m settings \u001b[38;5;241m=\u001b[39m Pickler\u001b[38;5;241m.\u001b[39msettings\n\u001b[1;32m    436\u001b[0m _ignore \u001b[38;5;241m=\u001b[39m kwds\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mignore\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 437\u001b[0m \u001b[43mStockUnpickler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    438\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_main \u001b[38;5;241m=\u001b[39m _main_module\n\u001b[1;32m    439\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ignore \u001b[38;5;241m=\u001b[39m settings[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mignore\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m _ignore \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m _ignore\n",
      "\u001b[0;31mTypeError\u001b[0m: file must have 'read' and 'readline' attributes"
     ]
    }
   ],
   "source": [
    "index = HNSW.load('index/hnsw_norm_0_1_100000_128_l2.pickle')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dill as pickle\n",
    "\n",
    "with open('index/hnsw_norm_0_1_100000_128_l2.pickle', 'rb') as f:\n",
    "    index = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HNSW Time: 5.858996868133545, Linear Time: 79.6040551662445\n"
     ]
    }
   ],
   "source": [
    "data = [point for point in index.values()]\n",
    "recall_list = []\n",
    "for i in range(1):\n",
    "    recalls = recall_with_topk(index, data, index._distance_func, max_topk=100)\n",
    "    recall_list.append(recalls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for r in recall_list:\n",
    "    plt.plot(range(1, 100), r)\n",
    "plt.xlabel('topk')\n",
    "plt.ylabel('recall')\n",
    "plt.title('recall with topk')\n",
    "plt.savefig('result/hnsw_recall_topk_norm_0_1_100000_128_l2.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ann",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
